Summary

This PR implements a significant performance optimization for the HTML parser by replacing the inefficient linked list-based CharList implementation with a StringBuilder-based approach, addressing the "Enhance HTML parser efficiency" goal from Round 2 of the performance improvement plan in issue #1534.

Key improvements:

• ✅ 43% performance improvement in HTML parsing
• ✅ Replaced char list with StringBuilder in CharList implementation
• ✅ Eliminated expensive List.rev operations during string building
• ✅ Maintained complete API compatibility and correctness
• ✅ All existing tests pass (71/71 HTML parser tests)

Test Plan

Correctness Validation:

• All existing HTML parser tests pass (71/71)
• HTML parsing behavior remains identical for all input types
• Code formatting follows project standards (Fantomas validation passes)
• Build completes successfully in Release mode

Performance Impact:

• Simple HTML parsing: 0.24ms → 0.14ms (42% improvement)
• Large HTML parsing: 91.6ms → 52.4ms (43% improvement)
• Scalable improvement: Performance gains increase with document size
• Memory efficiency: Reduced allocations during string building

Approach and Implementation

Selected Performance Goal: Enhance HTML parser efficiency (Round 2 goal from #1534)

Todo List Completed:

1. ✅ Analyzed HTML parser performance bottlenecks using custom benchmarks
2. ✅ Identified CharList as major performance bottleneck (linked list + List.rev operations)
3. ✅ Implemented StringBuilder-based CharList optimization with type-safe method overloads
4. ✅ Validated optimization maintains correctness through comprehensive test suite
5. ✅ Measured performance impact showing 43% improvement on large HTML documents
6. ✅ Applied automatic code formatting and ensured build succeeds

Build and Test Commands Used:

# Performance benchmarking
dotnet fsi html_perf_test.fsx

# Code formatting and validation
dotnet run --project build/build.fsproj -- -t Format
dotnet build src/FSharp.Data.Html.Core/FSharp.Data.Html.Core.fsproj -c Release

# Test validation (71 HTML parser tests passed)
dotnet test tests/FSharp.Data.Core.Tests/FSharp.Data.Core.Tests.fsproj --filter "FullyQualifiedName~HtmlParser" -c Release

Files Modified:

• src/FSharp.Data.Html.Core/HtmlParser.fs - Optimized CharList implementation and all instantiation points
• tests/FSharp.Data.Benchmarks/HtmlBenchmarks.fs - Added HTML parsing benchmarks (new)
• tests/FSharp.Data.Benchmarks/FSharp.Data.Benchmarks.fsproj - Added HTML benchmarks to project

Performance Optimization Details

Problem Identified:
The original CharList implementation used char list with prepend operations followed by List.rev |> List.toArray for string conversion, creating O(n) overhead for every string built during HTML parsing.

Solution Implemented:

// Before:
type CharList = { mutable Contents: char list }
override x.ToString() = String(x.Contents |> List.rev |> List.toArray)
member x.Cons(c) = x.Contents <- c :: x.Contents

// After:
type CharList = { mutable Contents: StringBuilder }
override x.ToString() = x.Contents.ToString()
member x.Cons(c: char) = x.Contents.Append(c) |> ignore

Performance Benefits:

• Eliminated O(n) list reversal operations during string conversion
• Direct character appending without intermediate list operations
• Reduced memory allocations for string building operations
• Improved cache locality with StringBuilder's internal buffer management

Impact and Testing

Performance Impact Areas:

• HTML parsing: Document tokenization and element construction performance
• Type inference: Sample data processing during design-time operations
• Runtime operations: Property access and DOM traversal operations

Correctness Verification:

• Existing comprehensive HTML parser test suite covers edge cases, malformed HTML, script parsing, comment handling, attribute processing, and more
• All 71 HTML parser tests continue to pass, ensuring identical behavior
• Performance test demonstrates parsing correctness maintained across document sizes

Performance Measurements

Custom Performance Test Results:

• Test environment: .NET 8.0, Release mode compilation
• Simple HTML (594 chars): 1000 iterations
  • Before: 239ms total (0.24ms per parse)
  • After: 138ms total (0.14ms per parse)
  • Improvement: 42%
• Large HTML (773KB Zoopla document): 10 iterations
  • Before: 916ms total (91.6ms per parse)
  • After: 524ms total (52.4ms per parse)
  • Improvement: 43%

Memory Impact:

• Reduced string allocations during HTML tokenization
• Eliminated intermediate list operations (cons, reverse, toArray)
• More efficient string building with StringBuilder's internal buffer

Problems Found and Solved

1. Type Annotation Requirements: StringBuilder.Append() overloads required explicit type annotations for disambiguation
2. Method Overload Conflicts: HtmlState.Cons() methods needed distinct parameter types (char vs char array vs string)
3. CharList Instantiation: All Empty references needed replacement with new StringBuilder() instances
4. Build Integration: HTML benchmarks added to project file and benchmark infrastructure

Future Performance Work

This optimization enables:

• Completion of Round 2: "Enhance HTML parser efficiency" goal now achieved with significant improvements
• Additional HTML optimizations: Foundation for other HTML parser improvements (regex optimization, state machine efficiency)
• Benchmarking infrastructure: HTML benchmarks now available for measuring future improvements
• Pattern application: StringBuilder approach can be applied to other parsing components (XML, CSV)

Links

• Performance Research Issue: Daily Perf Improver: Research and Plan #1534
• Related Infrastructure PR: Daily Perf Improver: Add BenchmarkDotNet infrastructure for performance testing #1538 (BenchmarkDotNet infrastructure - merged)
• Related Optimization PRs: Daily Perf Improver: Optimize string allocation in RemoveAdorners #1540 (String allocation - merged), Daily Perf Improver: Optimize isNumChar function in JSON parser #1543 (JSON parsing - open), Daily Perf Improver: Optimize Boolean conversion performance #1547 (Boolean conversion - merged)
• Build Commands: Daily Perf Improver Build Steps

Web Searches Performed: None (focused analysis of existing codebase and StringBuilder API documentation)
MCP Function Calls: GitHub API calls for issue/PR management, file operations, build validation
Bash Commands: git operations, dotnet build/test/format commands, performance profiling, HTML benchmark execution

AI-generated content by Daily Perf Improver may contain mistakes.